<!doctype html public "html2.0">
<html>
<head>
<title>The TSpaces Vision</title>
<!-- created by: Toby Lehman, 25-Jan-1998 -->
<meta name="abstract" content="TSpaces Vision ">
<meta name="keywords" content="TSpaces Java TupleSpace Database">
<meta name="owner"    content="toby@almaden.ibm.com">
<meta name="review"   content="19980125">
<meta name="security" content="public">
</head>

<! Set white background with red and purple links ->
<body bgcolor="#ffffff" text="#000000" link="#CC0000" alink="#ff3300" vlink="#330099">
<! Include the Masthead -> 
<center>
<img src="gifs/masthead.gif" alt="TSpaces" ALIGN = "middle" BORDER = 0 width=600 height=54>
  
</center>


<center>
<H1>The TSpaces Vision </H1>
</center>
<br clear=right>
<!----------------------------------------------------------------->
<center> <h2><a name="what">  What is TSpaces? </h2> </center>
<!----------------------------------------------------------------->
<p>
TSpaces is network middleware for the new age of ubiquitous computing.
A succinct description of TSpaces would be,
<b>a network communication buffer with database capabilities.</b>
However, it is often easier to describe it in terms of what it does.
It enables communication between applications and devices in a network of
heterogeneous computers and operating systems. TSpaces provides group
communication services, database services, URL-based file transfer
services, and event notification services.
It is implemented in the Java programming language and thus it
automatically possesses network ubiquity through platform independence,
as well as a standard type representation for all datatypes.
<br>
<center>
<img src="gifs/TSClientServer.gif"
    alt="A TS Server and a couple clients"
    ALIGN = "center" BORDER = 0 width = 640 >
</center>
<p>
In more technical terms,
TSpaces extends the basic Linda Tuplespace framework with real data management
and the ability to download both new datatypes and new semantic functionality.
The salient features of the TSpaces system are:
<ul>
<li> Tuplespace Operator Superset: TSpaces implements the standard set
of Tuplespace operators: read(tuple), take(tuple), write(tuple).
In addition,
it includes both blocking and non-blocking versions of take and read, set
oriented operators such as scan and consuming scan, and a novel rendezvous
operator, rhonda.
<li> Persistent Data Repository: TSpaces employs a real data management
layer, with functions similar to heavy-weight relational database systems,
to manage its data.   T Space operations are performed in a transactional
context, which ensures the integrity of the data.
<li> Database Indexing and Query Capability: The TSpaces data manager
indexes all tagged data for highly efficient retrieval.
The expanded query capability provides applications with the tools to probe
the data with detailed queries, while still maintaining a simple,
easy-to-use interface.
<li> Dynamically Modifiable Behavior: In addition to the expanded set of
built-in operators, TSpaces allows new operators to be defined
dynamically.
Applications can define new datatypes and new operators that are
downloaded into the TSpaces server and used immediately.
This is in contrast to relational database systems that have limited
datatype
support and limited dynamically defined function (usually in the
form of triggers or, to a lessor extent, user-defined functions).
<li> Event Notification: Applications can register to be notified of
events as they happen in the TSpaces server.
<li> Access Controls: Users can establish security policies by setting
user and group permissions on a Tuplespace and operator basis.
<li> Large Object Support:  Applications can specify URLs as field values.
The URL properties can be set as ``copy immediate'' or ``remote reference''.
``Copy Immediate'' implies that the contents of the URL are copied
between the client and server when the tuple is transferred.  ``Remote
Reference'' leaves the URL where it is.  However, another operator,
``getURL'' fetches the URL contents for local processing.
</ul>
<p>
The TSpaces system is appropriate for any application that has distribution
or data storage requirements.
It can perform many of the duties of a relational
database system without imposing an overly restrictive (and primitive) type
system, a rigid schema, a clumsy user interface or a severe runtime memory
requirement.  In a sense, it is a database system for the common everyday
computing device---one that doesn't generate complex SQL queries, but one
that needs reliable storage that is network accessible.
<!----------------------------------------------------------------->
<center> <h2><a name="Where">  Where is it going? </h2> </center>
<!----------------------------------------------------------------->
<p>
Since TSpaces basically connects all things to all things, there are
many things it is good at.  Also, since it is main memory and Java,
it is also ideal to do many things on very small devices, even those
(maybe especially those?) that do not have disk drives.  So, sure you can
build a chat room application, a shared whiteboard application, a
distributed cut and paste buffer application, a remote file system
viewer or tons of multi-user games.
However, there is <b>ONE MAIN THING</b> that we think TSpaces will
be especially good at.  It can (will?) be the common platform on which we
build links to all system and application services.  What do I mean
by that?  Suppose I want to print a file on a network printer
from a generic client.  That's fine if I have a UNIX client and a
UNIX network.  It's a little more involved if the client is Win NT or
Win95 and much more involved if the client is an Apple.
However, what if the client is a PDA?  At a large site, such as ours,
how do I go
about adding all 100 network printers to my Pilot interface?  How do I
even add one?   Now look at it from the other side.  When I have a private
locally attached Win 95 printer (or Mac printer, etc), how do I access
that from a UNIX machine?   Sure, there are specific answers to some
of these problems, with regard to printing, such as running a specialized
LP Daemon program that will talk to UNIX print clients.
Now let's cover scanning,
faxing, email, paging, application services (e.g. convert a word document
to a postscript file, invoke a web search on a topic, fetch and parse
XML data) or remote device control (e.g. drive a network attached
machine through an API, access a remote drive).
<p>
In the TSpaces world, a common computing environment, with access
to all possible network services, is surprisingly easy to build.
A set of applications, written in Java, map the system-specific
service (e.g. printing service) or application (e.g. web search)
to a standard tuple representation.  Then, any client from any
platform can generate a tuple and send it to a TSpaces server.
Applications, listening for specific tuples, pick up jobs when they
see them and execute them.  (This is all fairly fast, since it is
implemented with an underlying memory-resident database system.)
In building this environment, one would write the service application
to run on the platforms where they could do the most good.  At
the IBM Almaden Research Center, most network printers are visible
to AIX systems.  Therefore, one AIX printer service application could
listen for tuples posted to the "printing space", pick them up and
send them to an AIX Queue.  Similarly, queries about queues and
print status could also be done.   Then, on every other local
printer that should be attached to the common platform, a user
simply runs the local print application (although, in practice,
the local application can probably handle a number of services).
Notice, however, that we are NOT trying to replace any existing
tools or services---we are simply augmenting them with platform
independence and flexibility.
<p>
One of the really cool things about this environment is that
it injects a <i>smart</i> middleman into the picture.  So, as mentioned
above, you can build this nice platform independent print service
that gives you access to any printer in the building.  That might be
ok, but perhaps you don't have a clue about where all those printers
are.  With a smart middleman, you can add intelligence.   When your
PDA includes a location sensor (with no sensor you just have to tell it
which room you're in) the smart middleman printer client locates the
non-busy printer nearest you (that still has paper and toner) and sends the 
job there -- then shows you a map of how to get there.  When visiting
a new location, this sort of service would be incredibly convenient.
<p>
The number of common network services is limited only by our imaginations.
We're counting on the university population to come up with some revolutionary
ideas.  We've thought about cool ways to incorporate PDAs into the
network.  If they run Java, then great.  If not, then they will
have to communicate some other way, such as using TCP/IP and sending
only primitive types in the message.
<p>
There is one more important point to make (or two, depending on how you count).
First, this creates a <b>SINGLE</b> interface for talking to practically
every single service that exists on the network -- everything uses tuples.
The exact language that goes inside the tuples will have to be ironed
out over time, of course.  Second, while this all works fine from a command
line or GUI interface, tuples can be sent from <b>programs</b>
(from Java programs or from programs that invoke Java programs).  That
means that your program can easily send email, faxes, pages, print jobs,
web searches, remote device commands --- all as easy as sending or
receiving a tuple.
We've been waiting ages for smart agents to act on our collective behalf.
One of the things that has slowed down their progress is the interaction
to the outside world (so many different platforms, so many different
interfaces, so little time). 
<p>
(Editorial note:  Last year, a SUN Microsystems speaker confessed that
when SUN came out with the saying, "The Network *IS* the computer" they
really didn't know what they meant.  They just figured it would make
sense eventually.  Well, now it does.)
<p>
The generic diagram that we draw for TSpaces is below.  TSpaces,
this database enabled communication buffer, can connect absolutely
everything.  With an emerging world of smart, and network connected,
electronic devices, having an existing common platform, like TSpaces,
that they can plug into only makes them more powerful and useful
from the start.
<center>
<img src="gifs/TSGroup.gif"
    alt="A TS Network with various clients"
    ALIGN = "center" BORDER = 0 width = 640 >
</center>
Of course, the ubiquitous computing network is one side of the picture.
Simply being connected to TSpaces itself is convenient, even if you
don't use any network services.
For the client, being connected to TSpaces is like having the perfect
assistant: TSpaces will remember things for you, it will carry out any tasks
that you assign it, it will report incoming messages and deliver outgoing
messages, and it will notify you of any events in which you're interested.
Of course, if you want to use the network services,
TSpaces can be used as a universal
print service, email service, pager service, remote control service, and so
on.  Since it is written in Java, T Space client applications can be loaded
dynamically into any network-attached computer. The TSpaces package comes
with several useful applications that show how to build T Space clients.
The T Space server, also written in Java, can be upgraded while it is
running, thus avoiding costly downtime.
<BR><BR>
<!----------------------------------------------------------------->
<hr>
<! ------------------------------------------------------------------------->
[
<a href="../index.html" target=_top>
TSpaces home page </a>
]

</body>
